home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 423_01 / recio200 / recio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  13.3 KB  |  390 lines
  1. /*****************************************************************************
  2.    MODULE: recio.c
  3.   PURPOSE: recio primary functions
  4. COPYRIGHT: (C) 1994 William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.00
  8.   RELEASE: April 15, 1994
  9. *****************************************************************************/
  10.  
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <float.h>
  14. #include <limits.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include "recio.h"
  20.  
  21. #define rcol(rp)         ((rp)->r_colno)
  22. #define rflags(rp)       ((rp)->r_flags)
  23. #define rfd(rp)          ((rp)->r_fd)
  24. #define rfp(rp)          ((rp)->r_fp)
  25. #define rreclen(rp)      ((rp)->r_reclen)
  26. #define rrecsiz(rp)      ((rp)->r_recsiz)
  27. #define rfldsiz(rp)      ((rp)->r_fldsiz)
  28. #define rfldch(rp)       ((rp)->r_fldch)
  29. #define rtxtch(rp)       ((rp)->r_txtch)
  30.  
  31. /* private module variables */
  32. static REC *_RECS = NULL;              /* ptr to array of REC structures */
  33.  
  34. static REC rin  = { 1,      0,    stdin,  "stdin",     0L,
  35.                     0,      0,        0,        0,   NULL, 
  36.                     0,   NULL, RECFLDCH, RECTXTCH,  RECIN };
  37.  
  38. static REC rout = { 2, _R_WRT,   stdout, "stdout",     0L, 
  39.                     0,      0,        0,        0,   NULL, 
  40.                     0,   NULL, RECFLDCH, RECTXTCH, RECOUT };
  41.  
  42. static REC rerr = { 3, _R_WRT,   stderr, "stderr",     0L, 
  43.                     0,      0,        0,        0,   NULL, 
  44.                     0,   NULL, RECFLDCH, RECTXTCH, RECERR };
  45.  
  46. #if defined (__MSDOS__) || (MSDOS)
  47. static REC rprn = { 4, _R_WRT,   stdprn, "stdprn",     0L, 
  48.                     0,      0,        0,        0,   NULL, 
  49.                     0,   NULL, RECFLDCH, RECTXTCH, RECPRN };
  50. #define NREC      4          /* number of static record streams */
  51. #else
  52. #define NREC      3
  53. #endif
  54. #define ROPEN_MIN NREC       /* reserved for recin, etc */
  55. #define ROPEN     max(ROPEN_MAX, ROPEN_MIN)
  56.  
  57. /* public variables */
  58. REC *recin = &rin;
  59. REC *recout = &rout;
  60. REC *recerr = &rerr;
  61. #if defined (__MSDOS__) || (MSDOS)
  62. REC *recprn = &rprn;
  63. #endif
  64.  
  65. /* friend variables */
  66. char _r_nsbuf[NSBUFSIZ];     /* buffer for numeric to string conversions */
  67.  
  68. /* Support functions */
  69. /****************************************************************************/
  70. static void                  /* returns nothing                             */
  71.     _rexit(                  /* at program exit, clean up                   */
  72.         void)                /* no arguments                                */
  73. /****************************************************************************/
  74. {
  75.     /* free recin buffers */
  76.     free(rflds(recin));
  77.     free(rrecs(recin));
  78.     rflds(recin) = NULL;
  79.     rfldsiz(recin) = 0;
  80.     rrecs(recin) = NULL;
  81.     rrecsiz(recin) = 0;
  82.     rreclen(recin) = 0;
  83.  
  84.     /* ensure all record streams closed */
  85.     rcloseall();
  86. }
  87.  
  88. /****************************************************************************/
  89. void                         /* return error number (0=no error)            */
  90.     _rsetexitfn(             /* register _rexit function with atexit()      */
  91.         REC *rp)             /* record pointer                              */
  92. /****************************************************************************/
  93. {
  94.     static int once=0;       /* register exit fn only once */
  95.  
  96.     if (!once) {
  97.  
  98.         /* execute this path at most one time */
  99.         once++;
  100.  
  101.         /* if atexit() fails to register _rexit() function */
  102.         if (atexit(_rexit)) {
  103.  
  104.            /* register warning */
  105.            rsetwarn(rp, R_WNOREG);
  106.         }
  107.     }
  108. } 
  109.  
  110. /****************************************************************************/
  111. int                          /* return error number (0=no error)            */
  112.     _rstatus(                /* check stream for errors                     */
  113.         REC *rp,             /* record pointer                              */
  114.         int mode)            /* mode (0=read; !0=write/append)              */
  115. /****************************************************************************/
  116. {
  117.     int errnum=0;            /* error number */
  118.     int smode;               /* stream mode */
  119.  
  120.     /* test for valid record pointer */
  121.     if (!risvalid(rp)) {
  122.         errnum = rseterr(NULL, EINVAL);
  123.         goto done;
  124.     }
  125.     
  126.     /* if stream _R_WRT flag does not match mode */
  127.     smode = rflags(rp) & _R_WRT;
  128.     if ((mode && !smode) || (!mode && smode)) {
  129.         errnum = rseterr(rp, R_EINVMOD);
  130.         goto done;
  131.     }
  132.  
  133.     /* if record 0 and write mode */
  134.     if (!rrecno(rp) && mode) {
  135.         rrecno(rp)++;
  136.     }
  137.  
  138.     /* test for previous error */
  139.     errnum = rerror(rp);
  140.  
  141. done:
  142.     return (errnum);
  143. }
  144.  
  145. /****************************************************************************/
  146. static void                  /* returns nothing                             */
  147.     _rfree(                  /* free the memory allocated to a record       */
  148.         REC *rp)             /* record pointer                              */
  149. /****************************************************************************/
  150. {
  151.     if (risvalid(rp)) {
  152.         free(rflds(rp));
  153.         free(rrecs(rp));
  154.         if (rfp(rp))   fclose(rfp(rp));
  155.         memset(rp, 0, sizeof(REC));
  156.     }
  157. }
  158.  
  159. /* User functions */
  160. /****************************************************************************/
  161. REC *                        /* return record pointer                       */
  162.     ropen(                   /* open a record stream for reading            */
  163.         const char *fname,   /* name of file to open                        */
  164.         const char *mode)    /* type of mode used to open file              */
  165. /****************************************************************************/
  166. {
  167.     REC *rp = _RECS;         /* record pointer */
  168.     int  i;                  /* count of REC structures */
  169.     int  ch;                 /* first character of mode */
  170.     
  171.     /* only modes currently supported are "r", "w", and "a" */
  172.     ch = tolower(*mode);
  173.     if (!(ch=='r' || ch=='w' || ch=='a')) {
  174.         rp = NULL;
  175.         rseterr(NULL, EINVAL);
  176.         goto done;
  177.     }
  178.  
  179.     /* allocate memory for array of REC structures */
  180.     if (!rp) {
  181.         do {
  182.             /* note: no memory allocation needed for recin, etc */
  183.             rp = _RECS = (REC *) calloc(ROPEN-NREC, sizeof(REC));
  184.             if (!rp) {
  185.                 if (rseterr(NULL, ENOMEM)) goto done;
  186.             }
  187.         } while (!rp);
  188.     }
  189.  
  190.     /* search thru REC structures until empty position found */
  191.     for (i=NREC+1; i <= ROPEN; i++, rp++) {
  192.         if (!rfd(rp)) {
  193.             rfd(rp) = i;
  194.             break;
  195.         }
  196.     }
  197.     /* error if out of positions */
  198.     if (i > ROPEN) {
  199.         rp = NULL;
  200.         rseterr(NULL, EMFILE);
  201.         goto done;
  202.     }
  203.  
  204.     /* open file */
  205.     rfp(rp) = fopen(fname, mode);
  206.     if (!rfp(rp)) {
  207.         rclose(rp);
  208.         rp = NULL;
  209.         /* if error other than path/file not found */
  210.         if (errno != ENOENT) {
  211.             rseterr(NULL, errno);
  212.         }
  213.         goto done;
  214.     }
  215.  
  216.     /* initialize */
  217.     if (ch != 'r') rflags(rp)  |= _R_WRT;
  218.     rnames(rp)  = fname;
  219.     rrecno(rp)  = 0L;
  220.     rfldno(rp)  = 0;
  221.     rcol(rp)    = 0;
  222.     rrecsiz(rp) = 0;
  223.     rreclen(rp) = 0;
  224.     rrecs(rp)   = NULL;
  225.     rfldsiz(rp) = 0;
  226.     rflds(rp)   = NULL;
  227.     rfldch(rp)  = RECFLDCH;
  228.     rtxtch(rp)  = RECTXTCH;
  229.     _rsetexitfn(rp);
  230.  
  231. done:
  232.     return (rp);
  233. }
  234.  
  235. /****************************************************************************/
  236. int                          /* return error number (0=no error)            */
  237.     rclose(                  /* close a record stream                       */
  238.         REC *rp)             /* record pointer                              */
  239. /****************************************************************************/
  240. {
  241.     int errnum=0;            /* error number (0=no error) */
  242.     int i;                   /* count REC structures */
  243.     REC *recp=_RECS;         /* pointer to _RECS array */
  244.  
  245.     if (risvalid(rp)) {
  246.         /* close record stream, but not recin, recout, recerr */
  247.         if (rfd(rp) > NREC) _rfree(rp);
  248.  
  249.         /* if all record streams closed, free _RECS */
  250.         /* note: valid rp implies valid recp */
  251.         for (i=NREC+1; i <= ROPEN; i++, recp++) {
  252.             if (rfd(recp)) goto done;
  253.         }
  254.         free(_RECS);
  255.         _RECS = NULL;
  256.  
  257.     } else {
  258.         errnum = rseterr(NULL, EINVAL);
  259.     }
  260.  
  261. done:
  262.     return (errnum);
  263. }
  264.  
  265. /****************************************************************************/
  266. int                          /* returns number of streams closed            */
  267.     rcloseall(               /* close all record streams                    */
  268.         void)                /* no arguments                                */
  269. /****************************************************************************/
  270. {
  271.     int num=0;               /* number of streams closed */
  272.     int i;                   /* count REC structures */
  273.     REC *recp=_RECS;         /* pointer to _RECS array */
  274.  
  275.     /* close every open record stream, except recin, etc */
  276.     if (recp) {
  277.         for (i=NREC+1; i <= ROPEN; i++, recp++) {
  278.             if (rfd(recp)) {
  279.                 _rfree(recp);
  280.                 num++;
  281.             }
  282.         }
  283.         free(_RECS);
  284.         _RECS = NULL;
  285.     }
  286.     return (num);
  287. }
  288.  
  289. /****************************************************************************/
  290. int                          /* return !0 for valid; 0 for invalid          */
  291.     risvalid(                /* is record pointer valid?                    */
  292.         REC *rp)             /* record pointer                              */
  293. /****************************************************************************/
  294. {
  295.     int valid=1;             /* validation state (!0=valid) */
  296.  
  297.     /* if rp is null pointer or rfd not between 1 and ROPEN */
  298.     if (!rp || rfd(rp) < 1 || rfd(rp) > ROPEN) {
  299.         /* invalid record pointer */
  300.         valid = 0;
  301.     }
  302.     return (valid);
  303. }
  304.  
  305. /****************************************************************************/
  306. int                          /* return error number (0=no error)            */
  307.     rsetfldch(               /* set field separator character               */
  308.         REC *rp,             /* record pointer                              */
  309.         int  ch)             /* field separator character                   */
  310. /****************************************************************************/
  311. {
  312.     int errnum=0;            /* error number (0=no error) */
  313.  
  314.     if (risvalid(rp)) {
  315.         if (isascii(ch)) {
  316.             rfldch(rp) = ch;
  317.         } else {
  318.             errnum = rseterr(rp, R_EINVAL);
  319.         }
  320.     } else {
  321.         errnum = rseterr(NULL, EINVAL);
  322.     }
  323.     return (errnum);
  324. }
  325.  
  326. /****************************************************************************/
  327. int                          /* return error number (0=no error)            */
  328.     rsettxtch(               /* set text string delimiter character         */
  329.         REC *rp,             /* record pointer                              */
  330.         int  ch)             /* text delimiter character                    */
  331. /****************************************************************************/
  332. {
  333.     int errnum=0;            /* error number (0=no error) */
  334.  
  335.     if (risvalid(rp)) {
  336.         if (isascii(ch)) {
  337.             rtxtch(rp) = ch;
  338.         } else {
  339.             errnum = rseterr(rp, R_EINVAL);
  340.         }
  341.     } else {
  342.         errnum = rseterr(NULL, EINVAL);
  343.     }
  344.     return (errnum);
  345. }
  346.  
  347. /****************************************************************************/
  348. int                          /* return 0 on success; errnum on error        */
  349.     rsetcxtno(               /* set context number of record stream         */
  350.         REC *rp,             /* record pointer                              */
  351.         int  cxtno)          /* context number                              */
  352. /****************************************************************************/
  353. {
  354.     int errnum=0;            /* error number (0=no error) */
  355.  
  356.     if (risvalid(rp)) {
  357.         if (rcxtno(rp) >= 0  && cxtno >= 0) {
  358.             rcxtno(rp) = cxtno;
  359.         } else {
  360.             errnum = rseterr(rp, R_EINVAL);
  361.         }
  362.     } else {
  363.         errnum = rseterr(NULL, EINVAL);
  364.     }
  365.     return (errnum);
  366. }
  367.  
  368. /****************************************************************************/
  369. int                          /* return 0 on success; errnum on error        */
  370.     rsetbegcolno(            /* set beginning record column number          */
  371.         REC *rp,             /* record pointer                              */
  372.         int  colno)          /* first column in record is 0 or 1            */
  373. /****************************************************************************/
  374. {
  375.     int errnum=0;            /* error number (0=no error) */
  376.  
  377.     if (risvalid(rp)) {
  378.         if (colno == 1) {
  379.             rflags(rp) |= _R_COL;
  380.         } else if (colno == 0) {
  381.             rflags(rp) &= ~_R_COL;
  382.         } else {
  383.             errnum = rseterr(rp, R_EINVAL);
  384.         }
  385.     } else {
  386.         errnum = rseterr(NULL, EINVAL);
  387.     }
  388.     return (errnum);
  389. }
  390.